/*
    * Copyright (C) 2007 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.collect;
  
  import static com.google.common.base.Preconditions.checkArgument;
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.collect.CollectPreconditions.checkRemove;
  
  import com.google.common.annotations.Beta;
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.base.Function;
  import com.google.common.base.Optional;
  import com.google.common.base.Predicate;
  
  import java.util.Collection;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.NoSuchElementException;
  import java.util.Queue;
  import java.util.RandomAccess;
  import java.util.Set;
  
  import javax.annotation.Nullable;
  
  /**
   * This class contains static utility methods that operate on or return objects
   * of type {@code Iterable}. Except as noted, each method has a corresponding
   * {@link Iterator}-based method in the {@link Iterators} class.
   *
   * <p><i>Performance notes:</i> Unless otherwise noted, all of the iterables
   * produced in this class are <i>lazy</i>, which means that their iterators
   * only advance the backing iteration when absolutely necessary.
   *
   * <p>See the Guava User Guide article on <a href=
   * "http://code.google.com/p/guava-libraries/wiki/CollectionUtilitiesExplained#Iterables">
   * {@code Iterables}</a>.
   *
   * @author Kevin Bourrillion
   * @author Jared Levy
   * @since 2.0 (imported from Google Collections Library)
   */
  @GwtCompatible(emulated = true)
  public final class Iterables {
    private Iterables() {}
  
    /** Returns an unmodifiable view of {@code iterable}. */
    public static <T> Iterable<T> unmodifiableIterable(
        final Iterable<T> iterable) {
      checkNotNull(iterable);
      if (iterable instanceof UnmodifiableIterable ||
          iterable instanceof ImmutableCollection) {
        return iterable;
      }
      return new UnmodifiableIterable<T>(iterable);
    }
  
    /**
     * Simply returns its argument.
     *
     * @deprecated no need to use this
     * @since 10.0
     */
    @Deprecated public static <E> Iterable<E> unmodifiableIterable(
        ImmutableCollection<E> iterable) {
      return checkNotNull(iterable);
    }
  
    private static final class UnmodifiableIterable<T> extends FluentIterable<T> {
      private final Iterable<T> iterable;
  
      private UnmodifiableIterable(Iterable<T> iterable) {
        this.iterable = iterable;
      }
  
      @Override
      public Iterator<T> iterator() {
        return Iterators.unmodifiableIterator(iterable.iterator());
      }
  
      @Override
      public String toString() {
        return iterable.toString();
      }
      // no equals and hashCode; it would break the contract!
   }
 
   /**
    * Returns the number of elements in {@code iterable}.
    */
   public static int size(Iterable<?> iterable) {
     return (iterable instanceof Collection)
         ? ((Collection<?>) iterable).size()
         : Iterators.size(iterable.iterator());
   }
 
   /**
    * Returns {@code true} if {@code iterable} contains any object for which {@code equals(element)}
    * is true.
    */
   public static boolean contains(Iterable<?> iterable, @Nullable Object element) {
     if (iterable instanceof Collection) {
       Collection<?> collection = (Collection<?>) iterable;
       return Collections2.safeContains(collection, element);
     }
     return Iterators.contains(iterable.iterator(), element);
   }
 
   /**
    * Removes, from an iterable, every element that belongs to the provided
    * collection.
    *
    * <p>This method calls {@link Collection#removeAll} if {@code iterable} is a
    * collection, and {@link Iterators#removeAll} otherwise.
    *
    * @param removeFrom the iterable to (potentially) remove elements from
    * @param elementsToRemove the elements to remove
    * @return {@code true} if any element was removed from {@code iterable}
    */
   public static boolean removeAll(
       Iterable<?> removeFrom, Collection<?> elementsToRemove) {
     return (removeFrom instanceof Collection)
         ? ((Collection<?>) removeFrom).removeAll(checkNotNull(elementsToRemove))
         : Iterators.removeAll(removeFrom.iterator(), elementsToRemove);
   }
 
   /**
    * Removes, from an iterable, every element that does not belong to the
    * provided collection.
    *
    * <p>This method calls {@link Collection#retainAll} if {@code iterable} is a
    * collection, and {@link Iterators#retainAll} otherwise.
    *
    * @param removeFrom the iterable to (potentially) remove elements from
    * @param elementsToRetain the elements to retain
    * @return {@code true} if any element was removed from {@code iterable}
    */
   public static boolean retainAll(
       Iterable<?> removeFrom, Collection<?> elementsToRetain) {
     return (removeFrom instanceof Collection)
         ? ((Collection<?>) removeFrom).retainAll(checkNotNull(elementsToRetain))
         : Iterators.retainAll(removeFrom.iterator(), elementsToRetain);
   }
 
   /**
    * Removes, from an iterable, every element that satisfies the provided
    * predicate.
    *
    * @param removeFrom the iterable to (potentially) remove elements from
    * @param predicate a predicate that determines whether an element should
    *     be removed
    * @return {@code true} if any elements were removed from the iterable
    *
    * @throws UnsupportedOperationException if the iterable does not support
    *     {@code remove()}.
    * @since 2.0
    */
   public static <T> boolean removeIf(
       Iterable<T> removeFrom, Predicate<? super T> predicate) {
     if (removeFrom instanceof RandomAccess && removeFrom instanceof List) {
       return removeIfFromRandomAccessList(
           (List<T>) removeFrom, checkNotNull(predicate));
     }
     return Iterators.removeIf(removeFrom.iterator(), predicate);
   }
 
   private static <T> boolean removeIfFromRandomAccessList(
       List<T> list, Predicate<? super T> predicate) {
     // Note: Not all random access lists support set() so we need to deal with
     // those that don't and attempt the slower remove() based solution.
     int from = 0;
     int to = 0;
 
     for (; from < list.size(); from++) {
       T element = list.get(from);
       if (!predicate.apply(element)) {
         if (from > to) {
           try {
             list.set(to, element);
           } catch (UnsupportedOperationException e) {
             slowRemoveIfForRemainingElements(list, predicate, to, from);
             return true;
           }
         }
         to++;
       }
     }
 
     // Clear the tail of any remaining items
     list.subList(to, list.size()).clear();
     return from != to;
   }
 
   private static <T> void slowRemoveIfForRemainingElements(List<T> list,
       Predicate<? super T> predicate, int to, int from) {
     // Here we know that:
     // * (to < from) and that both are valid indices.
     // * Everything with (index < to) should be kept.
     // * Everything with (to <= index < from) should be removed.
     // * The element with (index == from) should be kept.
     // * Everything with (index > from) has not been checked yet.
 
     // Check from the end of the list backwards (minimize expected cost of
     // moving elements when remove() is called). Stop before 'from' because
     // we already know that should be kept.
     for (int n = list.size() - 1; n > from; n--) {
       if (predicate.apply(list.get(n))) {
         list.remove(n);
       }
     }
     // And now remove everything in the range [to, from) (going backwards).
     for (int n = from - 1; n >= to; n--) {
       list.remove(n);
     }
   }
 
   /**
    * Removes and returns the first matching element, or returns {@code null} if there is none.
    */
   @Nullable
   static <T> T removeFirstMatching(Iterable<T> removeFrom, Predicate<? super T> predicate) {
     checkNotNull(predicate);
     Iterator<T> iterator = removeFrom.iterator();
     while (iterator.hasNext()) {
       T next = iterator.next();
       if (predicate.apply(next)) {
         iterator.remove();
         return next;
       }
     }
     return null;
   }
 
   /**
    * Determines whether two iterables contain equal elements in the same order.
    * More specifically, this method returns {@code true} if {@code iterable1}
    * and {@code iterable2} contain the same number of elements and every element
    * of {@code iterable1} is equal to the corresponding element of
    * {@code iterable2}.
    */
   public static boolean elementsEqual(
       Iterable<?> iterable1, Iterable<?> iterable2) {
     if (iterable1 instanceof Collection && iterable2 instanceof Collection) {
       Collection<?> collection1 = (Collection<?>) iterable1;
       Collection<?> collection2 = (Collection<?>) iterable2;
       if (collection1.size() != collection2.size()) {
         return false;
       }
     }
     return Iterators.elementsEqual(iterable1.iterator(), iterable2.iterator());
   }
 
   /**
    * Returns a string representation of {@code iterable}, with the format {@code
    * [e1, e2, ..., en]} (that is, identical to {@link java.util.Arrays
    * Arrays}{@code .toString(Iterables.toArray(iterable))}). Note that for
    * <i>most</i> implementations of {@link Collection}, {@code
    * collection.toString()} also gives the same result, but that behavior is not
    * generally guaranteed.
    */
   public static String toString(Iterable<?> iterable) {
     return Iterators.toString(iterable.iterator());
   }
 
   /**
    * Returns the single element contained in {@code iterable}.
    *
    * @throws NoSuchElementException if the iterable is empty
    * @throws IllegalArgumentException if the iterable contains multiple
    *     elements
    */
   public static <T> T getOnlyElement(Iterable<T> iterable) {
     return Iterators.getOnlyElement(iterable.iterator());
   }
 
   /**
    * Returns the single element contained in {@code iterable}, or {@code
    * defaultValue} if the iterable is empty.
    *
    * @throws IllegalArgumentException if the iterator contains multiple
    *     elements
    */
   @Nullable
   public static <T> T getOnlyElement(
       Iterable<? extends T> iterable, @Nullable T defaultValue) {
     return Iterators.getOnlyElement(iterable.iterator(), defaultValue);
   }
 
   /**
    * Copies an iterable's elements into an array.
    *
    * @param iterable the iterable to copy
    * @return a newly-allocated array into which all the elements of the iterable
    *     have been copied
    */
   static Object[] toArray(Iterable<?> iterable) {
     return toCollection(iterable).toArray();
   }
 
   /**
    * Converts an iterable into a collection. If the iterable is already a
    * collection, it is returned. Otherwise, an {@link java.util.ArrayList} is
    * created with the contents of the iterable in the same iteration order.
    */
   private static <E> Collection<E> toCollection(Iterable<E> iterable) {
     return (iterable instanceof Collection)
         ? (Collection<E>) iterable
         : Lists.newArrayList(iterable.iterator());
   }
 
   /**
    * Adds all elements in {@code iterable} to {@code collection}.
    *
    * @return {@code true} if {@code collection} was modified as a result of this
    *     operation.
    */
   public static <T> boolean addAll(
       Collection<T> addTo, Iterable<? extends T> elementsToAdd) {
     if (elementsToAdd instanceof Collection) {
       Collection<? extends T> c = Collections2.cast(elementsToAdd);
       return addTo.addAll(c);
     }
     return Iterators.addAll(addTo, checkNotNull(elementsToAdd).iterator());
   }
 
   /**
    * Returns the number of elements in the specified iterable that equal the
    * specified object. This implementation avoids a full iteration when the
    * iterable is a {@link Multiset} or {@link Set}.
    *
    * @see Collections#frequency
    */
   public static int frequency(Iterable<?> iterable, @Nullable Object element) {
     if ((iterable instanceof Multiset)) {
       return ((Multiset<?>) iterable).count(element);
     } else if ((iterable instanceof Set)) {
       return ((Set<?>) iterable).contains(element) ? 1 : 0;
     }
     return Iterators.frequency(iterable.iterator(), element);
   }
 
   /**
    * Returns an iterable whose iterators cycle indefinitely over the elements of
    * {@code iterable}.
    *
    * <p>That iterator supports {@code remove()} if {@code iterable.iterator()}
    * does. After {@code remove()} is called, subsequent cycles omit the removed
    * element, which is no longer in {@code iterable}. The iterator's
    * {@code hasNext()} method returns {@code true} until {@code iterable} is
    * empty.
    *
    * <p><b>Warning:</b> Typical uses of the resulting iterator may produce an
    * infinite loop. You should use an explicit {@code break} or be certain that
    * you will eventually remove all the elements.
    *
    * <p>To cycle over the iterable {@code n} times, use the following:
    * {@code Iterables.concat(Collections.nCopies(n, iterable))}
    */
   public static <T> Iterable<T> cycle(final Iterable<T> iterable) {
     checkNotNull(iterable);
     return new FluentIterable<T>() {
       @Override
       public Iterator<T> iterator() {
         return Iterators.cycle(iterable);
       }
       @Override public String toString() {
         return iterable.toString() + " (cycled)";
       }
     };
   }
 
   /**
    * Returns an iterable whose iterators cycle indefinitely over the provided
    * elements.
    *
    * <p>After {@code remove} is invoked on a generated iterator, the removed
    * element will no longer appear in either that iterator or any other iterator
    * created from the same source iterable. That is, this method behaves exactly
    * as {@code Iterables.cycle(Lists.newArrayList(elements))}. The iterator's
    * {@code hasNext} method returns {@code true} until all of the original
    * elements have been removed.
    *
    * <p><b>Warning:</b> Typical uses of the resulting iterator may produce an
    * infinite loop. You should use an explicit {@code break} or be certain that
    * you will eventually remove all the elements.
    *
    * <p>To cycle over the elements {@code n} times, use the following:
    * {@code Iterables.concat(Collections.nCopies(n, Arrays.asList(elements)))}
    */
   public static <T> Iterable<T> cycle(T... elements) {
     return cycle(Lists.newArrayList(elements));
   }
 
   /**
    * Combines two iterables into a single iterable. The returned iterable has an
    * iterator that traverses the elements in {@code a}, followed by the elements
    * in {@code b}. The source iterators are not polled until necessary.
    *
    * <p>The returned iterable's iterator supports {@code remove()} when the
    * corresponding input iterator supports it.
    */
   public static <T> Iterable<T> concat(
       Iterable<? extends T> a, Iterable<? extends T> b) {
     return concat(ImmutableList.of(a, b));
   }
 
   /**
    * Combines three iterables into a single iterable. The returned iterable has
    * an iterator that traverses the elements in {@code a}, followed by the
    * elements in {@code b}, followed by the elements in {@code c}. The source
    * iterators are not polled until necessary.
    *
    * <p>The returned iterable's iterator supports {@code remove()} when the
    * corresponding input iterator supports it.
    */
   public static <T> Iterable<T> concat(Iterable<? extends T> a,
       Iterable<? extends T> b, Iterable<? extends T> c) {
     return concat(ImmutableList.of(a, b, c));
   }
 
   /**
    * Combines four iterables into a single iterable. The returned iterable has
    * an iterator that traverses the elements in {@code a}, followed by the
    * elements in {@code b}, followed by the elements in {@code c}, followed by
    * the elements in {@code d}. The source iterators are not polled until
    * necessary.
    *
    * <p>The returned iterable's iterator supports {@code remove()} when the
    * corresponding input iterator supports it.
    */
   public static <T> Iterable<T> concat(Iterable<? extends T> a,
       Iterable<? extends T> b, Iterable<? extends T> c,
       Iterable<? extends T> d) {
     return concat(ImmutableList.of(a, b, c, d));
   }
 
   /**
    * Combines multiple iterables into a single iterable. The returned iterable
    * has an iterator that traverses the elements of each iterable in
    * {@code inputs}. The input iterators are not polled until necessary.
    *
    * <p>The returned iterable's iterator supports {@code remove()} when the
    * corresponding input iterator supports it.
    *
    * @throws NullPointerException if any of the provided iterables is null
    */
   public static <T> Iterable<T> concat(Iterable<? extends T>... inputs) {
     return concat(ImmutableList.copyOf(inputs));
   }
 
   /**
    * Combines multiple iterables into a single iterable. The returned iterable
    * has an iterator that traverses the elements of each iterable in
    * {@code inputs}. The input iterators are not polled until necessary.
    *
    * <p>The returned iterable's iterator supports {@code remove()} when the
    * corresponding input iterator supports it. The methods of the returned
    * iterable may throw {@code NullPointerException} if any of the input
    * iterators is null.
    */
   public static <T> Iterable<T> concat(
       final Iterable<? extends Iterable<? extends T>> inputs) {
     checkNotNull(inputs);
     return new FluentIterable<T>() {
       @Override
       public Iterator<T> iterator() {
         return Iterators.concat(iterators(inputs));
       }
     };
   }
 
   /**
    * Returns an iterator over the iterators of the given iterables.
    */
   private static <T> Iterator<Iterator<? extends T>> iterators(
       Iterable<? extends Iterable<? extends T>> iterables) {
     return new TransformedIterator<Iterable<? extends T>, Iterator<? extends T>>(
         iterables.iterator()) {
       @Override
       Iterator<? extends T> transform(Iterable<? extends T> from) {
         return from.iterator();
       }
     };
   }
 
   /**
    * Divides an iterable into unmodifiable sublists of the given size (the final
    * iterable may be smaller). For example, partitioning an iterable containing
    * {@code [a, b, c, d, e]} with a partition size of 3 yields {@code
    * [[a, b, c], [d, e]]} -- an outer iterable containing two inner lists of
    * three and two elements, all in the original order.
    *
    * <p>Iterators returned by the returned iterable do not support the {@link
    * Iterator#remove()} method. The returned lists implement {@link
    * RandomAccess}, whether or not the input list does.
    *
    * <p><b>Note:</b> if {@code iterable} is a {@link List}, use {@link
    * Lists#partition(List, int)} instead.
    *
    * @param iterable the iterable to return a partitioned view of
    * @param size the desired size of each partition (the last may be smaller)
    * @return an iterable of unmodifiable lists containing the elements of {@code
    *     iterable} divided into partitions
    * @throws IllegalArgumentException if {@code size} is nonpositive
    */
   public static <T> Iterable<List<T>> partition(
       final Iterable<T> iterable, final int size) {
     checkNotNull(iterable);
     checkArgument(size > 0);
     return new FluentIterable<List<T>>() {
       @Override
       public Iterator<List<T>> iterator() {
         return Iterators.partition(iterable.iterator(), size);
       }
     };
   }
 
   /**
    * Divides an iterable into unmodifiable sublists of the given size, padding
    * the final iterable with null values if necessary. For example, partitioning
    * an iterable containing {@code [a, b, c, d, e]} with a partition size of 3
    * yields {@code [[a, b, c], [d, e, null]]} -- an outer iterable containing
    * two inner lists of three elements each, all in the original order.
    *
    * <p>Iterators returned by the returned iterable do not support the {@link
    * Iterator#remove()} method.
    *
    * @param iterable the iterable to return a partitioned view of
    * @param size the desired size of each partition
    * @return an iterable of unmodifiable lists containing the elements of {@code
    *     iterable} divided into partitions (the final iterable may have
    *     trailing null elements)
    * @throws IllegalArgumentException if {@code size} is nonpositive
    */
   public static <T> Iterable<List<T>> paddedPartition(
       final Iterable<T> iterable, final int size) {
     checkNotNull(iterable);
     checkArgument(size > 0);
     return new FluentIterable<List<T>>() {
       @Override
       public Iterator<List<T>> iterator() {
         return Iterators.paddedPartition(iterable.iterator(), size);
       }
     };
   }
 
   /**
    * Returns the elements of {@code unfiltered} that satisfy a predicate. The
    * resulting iterable's iterator does not support {@code remove()}.
    */
   public static <T> Iterable<T> filter(
       final Iterable<T> unfiltered, final Predicate<? super T> predicate) {
     checkNotNull(unfiltered);
     checkNotNull(predicate);
     return new FluentIterable<T>() {
       @Override
       public Iterator<T> iterator() {
         return Iterators.filter(unfiltered.iterator(), predicate);
       }
     };
   }
 
   /**
    * Returns {@code true} if any element in {@code iterable} satisfies the predicate.
    */
   public static <T> boolean any(
       Iterable<T> iterable, Predicate<? super T> predicate) {
     return Iterators.any(iterable.iterator(), predicate);
   }
 
   /**
    * Returns {@code true} if every element in {@code iterable} satisfies the
    * predicate. If {@code iterable} is empty, {@code true} is returned.
    */
   public static <T> boolean all(
       Iterable<T> iterable, Predicate<? super T> predicate) {
     return Iterators.all(iterable.iterator(), predicate);
   }
 
   /**
    * Returns the first element in {@code iterable} that satisfies the given
    * predicate; use this method only when such an element is known to exist. If
    * it is possible that <i>no</i> element will match, use {@link #tryFind} or
    * {@link #find(Iterable, Predicate, Object)} instead.
    *
    * @throws NoSuchElementException if no element in {@code iterable} matches
    *     the given predicate
    */
   public static <T> T find(Iterable<T> iterable,
       Predicate<? super T> predicate) {
     return Iterators.find(iterable.iterator(), predicate);
   }
 
   /**
    * Returns the first element in {@code iterable} that satisfies the given
    * predicate, or {@code defaultValue} if none found. Note that this can
    * usually be handled more naturally using {@code
    * tryFind(iterable, predicate).or(defaultValue)}.
    *
    * @since 7.0
    */
   @Nullable
   public static <T> T find(Iterable<? extends T> iterable,
       Predicate<? super T> predicate, @Nullable T defaultValue) {
     return Iterators.find(iterable.iterator(), predicate, defaultValue);
   }
 
   /**
    * Returns an {@link Optional} containing the first element in {@code
    * iterable} that satisfies the given predicate, if such an element exists.
    *
    * <p><b>Warning:</b> avoid using a {@code predicate} that matches {@code
    * null}. If {@code null} is matched in {@code iterable}, a
    * NullPointerException will be thrown.
    *
    * @since 11.0
    */
   public static <T> Optional<T> tryFind(Iterable<T> iterable,
       Predicate<? super T> predicate) {
     return Iterators.tryFind(iterable.iterator(), predicate);
   }
 
   /**
    * Returns the index in {@code iterable} of the first element that satisfies
    * the provided {@code predicate}, or {@code -1} if the Iterable has no such
    * elements.
    *
    * <p>More formally, returns the lowest index {@code i} such that
    * {@code predicate.apply(Iterables.get(iterable, i))} returns {@code true},
    * or {@code -1} if there is no such index.
    *
    * @since 2.0
    */
   public static <T> int indexOf(
       Iterable<T> iterable, Predicate<? super T> predicate) {
     return Iterators.indexOf(iterable.iterator(), predicate);
   }
 
   /**
    * Returns an iterable that applies {@code function} to each element of {@code
    * fromIterable}.
    *
    * <p>The returned iterable's iterator supports {@code remove()} if the
    * provided iterator does. After a successful {@code remove()} call,
    * {@code fromIterable} no longer contains the corresponding element.
    *
    * <p>If the input {@code Iterable} is known to be a {@code List} or other
    * {@code Collection}, consider {@link Lists#transform} and {@link
    * Collections2#transform}.
    */
   public static <F, T> Iterable<T> transform(final Iterable<F> fromIterable,
       final Function<? super F, ? extends T> function) {
     checkNotNull(fromIterable);
     checkNotNull(function);
     return new FluentIterable<T>() {
       @Override
       public Iterator<T> iterator() {
         return Iterators.transform(fromIterable.iterator(), function);
       }
     };
   }
 
   /**
    * Returns the element at the specified position in an iterable.
    *
    * @param position position of the element to return
    * @return the element at the specified position in {@code iterable}
    * @throws IndexOutOfBoundsException if {@code position} is negative or
    *     greater than or equal to the size of {@code iterable}
    */
   public static <T> T get(Iterable<T> iterable, int position) {
     checkNotNull(iterable);
     return (iterable instanceof List)
         ? ((List<T>) iterable).get(position)
         : Iterators.get(iterable.iterator(), position);
   }
 
   /**
    * Returns the element at the specified position in an iterable or a default
    * value otherwise.
    *
    * @param position position of the element to return
    * @param defaultValue the default value to return if {@code position} is
    *     greater than or equal to the size of the iterable
    * @return the element at the specified position in {@code iterable} or
    *     {@code defaultValue} if {@code iterable} contains fewer than
    *     {@code position + 1} elements.
    * @throws IndexOutOfBoundsException if {@code position} is negative
    * @since 4.0
    */
   @Nullable
   public static <T> T get(Iterable<? extends T> iterable, int position, @Nullable T defaultValue) {
     checkNotNull(iterable);
     Iterators.checkNonnegative(position);
     if (iterable instanceof List) {
       List<? extends T> list = Lists.cast(iterable);
       return (position < list.size()) ? list.get(position) : defaultValue;
     } else {
       Iterator<? extends T> iterator = iterable.iterator();
       Iterators.advance(iterator, position);
       return Iterators.getNext(iterator, defaultValue);
     }
   }
 
   /**
    * Returns the first element in {@code iterable} or {@code defaultValue} if
    * the iterable is empty.  The {@link Iterators} analog to this method is
    * {@link Iterators#getNext}.
    *
    * <p>If no default value is desired (and the caller instead wants a
    * {@link NoSuchElementException} to be thrown), it is recommended that
    * {@code iterable.iterator().next()} is used instead.
    *
    * @param defaultValue the default value to return if the iterable is empty
    * @return the first element of {@code iterable} or the default value
    * @since 7.0
    */
   @Nullable
   public static <T> T getFirst(Iterable<? extends T> iterable, @Nullable T defaultValue) {
     return Iterators.getNext(iterable.iterator(), defaultValue);
   }
 
   /**
    * Returns the last element of {@code iterable}.
    *
    * @return the last element of {@code iterable}
    * @throws NoSuchElementException if the iterable is empty
    */
   public static <T> T getLast(Iterable<T> iterable) {
     // TODO(kevinb): Support a concurrently modified collection?
     if (iterable instanceof List) {
       List<T> list = (List<T>) iterable;
       if (list.isEmpty()) {
         throw new NoSuchElementException();
       }
       return getLastInNonemptyList(list);
     }
 
     return Iterators.getLast(iterable.iterator());
   }
 
   /**
    * Returns the last element of {@code iterable} or {@code defaultValue} if
    * the iterable is empty.
    *
    * @param defaultValue the value to return if {@code iterable} is empty
    * @return the last element of {@code iterable} or the default value
    * @since 3.0
    */
   @Nullable
   public static <T> T getLast(Iterable<? extends T> iterable, @Nullable T defaultValue) {
     if (iterable instanceof Collection) {
       Collection<? extends T> c = Collections2.cast(iterable);
       if (c.isEmpty()) {
         return defaultValue;
       } else if (iterable instanceof List) {
         return getLastInNonemptyList(Lists.cast(iterable));
       }
     }
 
     return Iterators.getLast(iterable.iterator(), defaultValue);
   }
 
   private static <T> T getLastInNonemptyList(List<T> list) {
     return list.get(list.size() - 1);
   }
 
   /**
    * Returns a view of {@code iterable} that skips its first
    * {@code numberToSkip} elements. If {@code iterable} contains fewer than
    * {@code numberToSkip} elements, the returned iterable skips all of its
    * elements.
    *
    * <p>Modifications to the underlying {@link Iterable} before a call to
    * {@code iterator()} are reflected in the returned iterator. That is, the
    * iterator skips the first {@code numberToSkip} elements that exist when the
    * {@code Iterator} is created, not when {@code skip()} is called.
    *
    * <p>The returned iterable's iterator supports {@code remove()} if the
    * iterator of the underlying iterable supports it. Note that it is
    * <i>not</i> possible to delete the last skipped element by immediately
    * calling {@code remove()} on that iterator, as the {@code Iterator}
    * contract states that a call to {@code remove()} before a call to
    * {@code next()} will throw an {@link IllegalStateException}.
    *
    * @since 3.0
    */
   public static <T> Iterable<T> skip(final Iterable<T> iterable,
       final int numberToSkip) {
     checkNotNull(iterable);
     checkArgument(numberToSkip >= 0, "number to skip cannot be negative");
 
     if (iterable instanceof List) {
       final List<T> list = (List<T>) iterable;
       return new FluentIterable<T>() {
         @Override
         public Iterator<T> iterator() {
           // TODO(kevinb): Support a concurrently modified collection?
           int toSkip = Math.min(list.size(), numberToSkip);
           return list.subList(toSkip, list.size()).iterator();
         }
       };
     }
 
     return new FluentIterable<T>() {
       @Override
       public Iterator<T> iterator() {
         final Iterator<T> iterator = iterable.iterator();
 
         Iterators.advance(iterator, numberToSkip);
 
         /*
          * We can't just return the iterator because an immediate call to its
          * remove() method would remove one of the skipped elements instead of
          * throwing an IllegalStateException.
          */
         return new Iterator<T>() {
           boolean atStart = true;
 
           @Override
           public boolean hasNext() {
             return iterator.hasNext();
           }
 
           @Override
           public T next() {
             T result = iterator.next();
             atStart = false; // not called if next() fails
             return result;
           }
 
           @Override
           public void remove() {
             checkRemove(!atStart);
             iterator.remove();
           }
         };
       }
     };
   }
 
   /**
    * Creates an iterable with the first {@code limitSize} elements of the given
    * iterable. If the original iterable does not contain that many elements, the
    * returned iterable will have the same behavior as the original iterable. The
    * returned iterable's iterator supports {@code remove()} if the original
    * iterator does.
    *
    * @param iterable the iterable to limit
    * @param limitSize the maximum number of elements in the returned iterable
    * @throws IllegalArgumentException if {@code limitSize} is negative
    * @since 3.0
    */
   public static <T> Iterable<T> limit(
       final Iterable<T> iterable, final int limitSize) {
     checkNotNull(iterable);
     checkArgument(limitSize >= 0, "limit is negative");
     return new FluentIterable<T>() {
       @Override
       public Iterator<T> iterator() {
         return Iterators.limit(iterable.iterator(), limitSize);
       }
     };
   }
 
   /**
    * Returns a view of the supplied iterable that wraps each generated
    * {@link Iterator} through {@link Iterators#consumingIterator(Iterator)}.
    *
    * <p>Note: If {@code iterable} is a {@link Queue}, the returned iterable will
    * get entries from {@link Queue#remove()} since {@link Queue}'s iteration
    * order is undefined.  Calling {@link Iterator#hasNext()} on a generated
    * iterator from the returned iterable may cause an item to be immediately
    * dequeued for return on a subsequent call to {@link Iterator#next()}.
    *
    * @param iterable the iterable to wrap
    * @return a view of the supplied iterable that wraps each generated iterator
    *     through {@link Iterators#consumingIterator(Iterator)}; for queues,
    *     an iterable that generates iterators that return and consume the
    *     queue's elements in queue order
    *
    * @see Iterators#consumingIterator(Iterator)
    * @since 2.0
    */
   public static <T> Iterable<T> consumingIterable(final Iterable<T> iterable) {
     if (iterable instanceof Queue) {
       return new FluentIterable<T>() {
         @Override
         public Iterator<T> iterator() {
           return new ConsumingQueueIterator<T>((Queue<T>) iterable);
         }
 
         @Override
         public String toString() {
           return "Iterables.consumingIterable(...)";
         }
       };
     }
 
     checkNotNull(iterable);
 
     return new FluentIterable<T>() {
       @Override
       public Iterator<T> iterator() {
         return Iterators.consumingIterator(iterable.iterator());
       }
 
       @Override
       public String toString() {
         return "Iterables.consumingIterable(...)";
       }
     };
   }
 
   private static class ConsumingQueueIterator<T> extends AbstractIterator<T> {
     private final Queue<T> queue;
 
     private ConsumingQueueIterator(Queue<T> queue) {
       this.queue = queue;
     }
 
     @Override public T computeNext() {
       try {
         return queue.remove();
       } catch (NoSuchElementException e) {
         return endOfData();
       }
     }
   }
 
   // Methods only in Iterables, not in Iterators
 
   /**
    * Determines if the given iterable contains no elements.
    *
    * <p>There is no precise {@link Iterator} equivalent to this method, since
    * one can only ask an iterator whether it has any elements <i>remaining</i>
    * (which one does using {@link Iterator#hasNext}).
    *
    * @return {@code true} if the iterable contains no elements
    */
   public static boolean isEmpty(Iterable<?> iterable) {
     if (iterable instanceof Collection) {
       return ((Collection<?>) iterable).isEmpty();
     }
     return !iterable.iterator().hasNext();
   }
 
   /**
    * Returns an iterable over the merged contents of all given
    * {@code iterables}. Equivalent entries will not be de-duplicated.
    *
    * <p>Callers must ensure that the source {@code iterables} are in
    * non-descending order as this method does not sort its input.
    *
    * <p>For any equivalent elements across all {@code iterables}, it is
    * undefined which element is returned first.
    *
    * @since 11.0
    */
   @Beta
   public static <T> Iterable<T> mergeSorted(
       final Iterable<? extends Iterable<? extends T>> iterables,
       final Comparator<? super T> comparator) {
     checkNotNull(iterables, "iterables");
     checkNotNull(comparator, "comparator");
     Iterable<T> iterable = new FluentIterable<T>() {
       @Override
       public Iterator<T> iterator() {
         return Iterators.mergeSorted(
             Iterables.transform(iterables, Iterables.<T>toIterator()),
             comparator);
       }
     };
     return new UnmodifiableIterable<T>(iterable);
   }
 
   // TODO(user): Is this the best place for this? Move to fluent functions?
   // Useful as a public method?
   private static <T> Function<Iterable<? extends T>, Iterator<? extends T>>
       toIterator() {
     return new Function<Iterable<? extends T>, Iterator<? extends T>>() {
       @Override
       public Iterator<? extends T> apply(Iterable<? extends T> iterable) {
         return iterable.iterator();
       }
     };
   }
 }